{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys \n",
    "\n",
    "# Modify the path \n",
    "sys.path.append(\"..\")\n",
    "\n",
    "import pandas as pd\n",
    "import yellowbrick as yb\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "from sklearn.linear_model import LogisticRegression, Lasso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# yellowbrick.features.importances\n",
    "# Feature importance visualizer\n",
    "#\n",
    "# Author:  Benjamin Bengfort <benjamin@bengfort.com>\n",
    "# Created: Fri Mar 02 15:21:36 2018 -0500\n",
    "# Author:  Rebecca Bilbro <rbilbro@districtdatalabs.com>\n",
    "# Updated: Sun Jun 24 10:53:36 2018 -0500\n",
    "#\n",
    "# Copyright (C) 2018 District Data Labs\n",
    "# For license information, see LICENSE.txt\n",
    "#\n",
    "# ID: importances.py [] benjamin@bengfort.com $\n",
    "\n",
    "\"\"\"\n",
    "Implementation of a feature importances visualizer. This visualizer sits in\n",
    "kind of a weird place since it is technically a model scoring visualizer, but\n",
    "is generally used for feature engineering.\n",
    "\"\"\"\n",
    "\n",
    "##########################################################################\n",
    "## Imports\n",
    "##########################################################################\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from yellowbrick.utils import is_dataframe\n",
    "from yellowbrick.base import ModelVisualizer\n",
    "from yellowbrick.exceptions import YellowbrickTypeError, NotFitted\n",
    "\n",
    "\n",
    "##########################################################################\n",
    "## Feature Visualizer\n",
    "##########################################################################\n",
    "\n",
    "class FeatureImportances(ModelVisualizer):\n",
    "    \"\"\"\n",
    "    Displays the most informative features in a model by showing a bar chart\n",
    "    of features ranked by their importances. Although primarily a feature\n",
    "    engineering mechanism, this visualizer requires a model that has either a\n",
    "    ``coef_`` or ``feature_importances_`` parameter after fit.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : Estimator\n",
    "        A Scikit-Learn estimator that learns feature importances. Must support\n",
    "        either ``coef_`` or ``feature_importances_`` parameters.\n",
    "\n",
    "    ax : matplotlib Axes, default: None\n",
    "        The axis to plot the figure on. If None is passed in the current axes\n",
    "        will be used (or generated if required).\n",
    "\n",
    "    labels : list, default: None\n",
    "        A list of feature names to use. If a DataFrame is passed to fit and\n",
    "        features is None, feature names are selected as the column names.\n",
    "\n",
    "    relative : bool, default: True\n",
    "        If true, the features are described by their relative importance as a\n",
    "        percentage of the strongest feature component; otherwise the raw\n",
    "        numeric description of the feature importance is shown.\n",
    "\n",
    "    absolute : bool, default: False\n",
    "        Make all coeficients absolute to more easily compare negative\n",
    "        coeficients with positive ones.\n",
    "\n",
    "    xlabel : str, default: None\n",
    "        The label for the X-axis. If None is automatically determined by the\n",
    "        underlying model and options provided.\n",
    "\n",
    "    kwargs : dict\n",
    "        Keyword arguments that are passed to the base class and may influence\n",
    "        the visualization as defined in other Visualizers.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    features_ : np.array\n",
    "        The feature labels ranked according to their importance\n",
    "\n",
    "    feature_importances_ : np.array\n",
    "        The numeric value of the feature importance computed by the model\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "\n",
    "    >>> from sklearn.ensemble import GradientBoostingClassifier\n",
    "    >>> visualizer = FeatureImportances(GradientBoostingClassifier())\n",
    "    >>> visualizer.fit(X, y)\n",
    "    >>> visualizer.show()\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, model, ax=None, labels=None, relative=True,\n",
    "                 absolute=False, xlabel=None, **kwargs):\n",
    "        super(FeatureImportances, self).__init__(model, ax, **kwargs)\n",
    "\n",
    "        # Data Parameters\n",
    "        self.set_params(\n",
    "            labels=labels, relative=relative, absolute=absolute,\n",
    "            xlabel=xlabel,\n",
    "        )\n",
    "\n",
    "    def fit(self, X, y=None, **kwargs):\n",
    "        \"\"\"\n",
    "        Fits the estimator to discover the feature importances described by\n",
    "        the data, then draws those importances as a bar plot.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        X : ndarray or DataFrame of shape n x m\n",
    "            A matrix of n instances with m features\n",
    "\n",
    "        y : ndarray or Series of length n\n",
    "            An array or series of target or class values\n",
    "\n",
    "        kwargs : dict\n",
    "            Keyword arguments passed to the fit method of the estimator.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        self : visualizer\n",
    "            The fit method must always return self to support pipelines.\n",
    "        \"\"\"\n",
    "        super(FeatureImportances, self).fit(X, y, **kwargs)\n",
    "\n",
    "        # Get the feature importances from the model\n",
    "        self.feature_importances_ = self._find_importances_param()\n",
    "        \n",
    "        # Check if feature importances is a multidimensional array & if so flatten\n",
    "        if self.feature_importances_.ndim > 1:\n",
    "            self.feature_importances_ = np.mean(self.feature_importances_, axis=0)\n",
    "\n",
    "        # Apply absolute value filter before normalization\n",
    "        if self.absolute:\n",
    "            self.feature_importances_ = np.abs(self.feature_importances_)\n",
    "\n",
    "        # Normalize features relative to the maximum\n",
    "        if self.relative:\n",
    "            maxv = self.feature_importances_.max()\n",
    "            self.feature_importances_ /= maxv\n",
    "            self.feature_importances_ *= 100.0\n",
    "\n",
    "        # Create labels for the feature importances\n",
    "        # NOTE: this code is duplicated from MultiFeatureVisualizer\n",
    "        if self.labels is None:\n",
    "            # Use column names if a dataframe\n",
    "            if is_dataframe(X):\n",
    "                self.features_ = np.array(X.columns)\n",
    "\n",
    "            # Otherwise use the column index as the labels\n",
    "            else:\n",
    "                _, ncols = X.shape\n",
    "                self.features_ = np.arange(0, ncols)\n",
    "        else:\n",
    "            self.features_ = np.array(self.labels)\n",
    "\n",
    "        # Sort the features and their importances\n",
    "        sort_idx = np.argsort(self.feature_importances_)\n",
    "        self.features_ = self.features_[sort_idx]\n",
    "        self.feature_importances_ = self.feature_importances_[sort_idx]\n",
    "\n",
    "        # Draw the feature importances\n",
    "        self.draw()\n",
    "        return self\n",
    "\n",
    "    def draw(self, **kwargs):\n",
    "        \"\"\"\n",
    "        Draws the feature importances as a bar chart; called from fit.\n",
    "        \"\"\"\n",
    "        # Quick validation\n",
    "        for param in ('feature_importances_', 'features_'):\n",
    "            if not hasattr(self, param):\n",
    "                raise NotFitted(\"missing required param '{}'\".format(param))\n",
    "\n",
    "        # Find the positions for each bar\n",
    "        pos = np.arange(self.features_.shape[0]) + 0.5\n",
    "\n",
    "        # Plot the bar chart\n",
    "        self.ax.barh(pos, self.feature_importances_, align='center')\n",
    "\n",
    "        # Set the labels for the bars\n",
    "        self.ax.set_yticks(pos)\n",
    "        self.ax.set_yticklabels(self.features_)\n",
    "\n",
    "        return self.ax\n",
    "\n",
    "    def finalize(self, **kwargs):\n",
    "        \"\"\"\n",
    "        Finalize the drawing setting labels and title.\n",
    "        \"\"\"\n",
    "        # Set the title\n",
    "        self.set_title('Feature Importances of {} Features using {}'.format(\n",
    "                len(self.features_), self.name))\n",
    "\n",
    "        # Set the xlabel\n",
    "        self.ax.set_xlabel(self._get_xlabel())\n",
    "\n",
    "        # Remove the ygrid\n",
    "        self.ax.grid(False, axis='y')\n",
    "\n",
    "        # Ensure we have a tight fit\n",
    "        plt.tight_layout()\n",
    "\n",
    "    def _find_importances_param(self):\n",
    "        \"\"\"\n",
    "        Searches the wrapped model for the feature importances parameter.\n",
    "        \"\"\"\n",
    "        for attr in (\"feature_importances_\", \"coef_\"):\n",
    "            try:\n",
    "                return getattr(self.estimator, attr)\n",
    "            except AttributeError:\n",
    "                continue\n",
    "\n",
    "        raise YellowbrickTypeError(\n",
    "            \"could not find feature importances param on {}\".format(\n",
    "                self.estimator.__class__.__name__\n",
    "            )\n",
    "        )\n",
    "\n",
    "    def _get_xlabel(self):\n",
    "        \"\"\"\n",
    "        Determines the xlabel based on the underlying data structure\n",
    "        \"\"\"\n",
    "        # Return user-specified label\n",
    "        if self.xlabel:\n",
    "            return self.xlabel\n",
    "\n",
    "        # Label for coefficients\n",
    "        if hasattr(self.estimator, \"coef_\"):\n",
    "            if self.relative:\n",
    "                return \"relative coefficient magnitude\"\n",
    "            return \"coefficient value\"\n",
    "\n",
    "        # Default label for feature_importances_\n",
    "        if self.relative:\n",
    "            return \"relative importance\"\n",
    "        return \"feature importance\"\n",
    "\n",
    "    def _is_fitted(self):\n",
    "        \"\"\"\n",
    "        Returns true if the visualizer has been fit.\n",
    "        \"\"\"\n",
    "        return hasattr(self, 'feature_importances_') and hasattr(self, 'features_')\n",
    "\n",
    "\n",
    "##########################################################################\n",
    "## Quick Method\n",
    "##########################################################################\n",
    "\n",
    "def feature_importances(model, X, y=None, ax=None, labels=None,\n",
    "                        relative=True, absolute=False, xlabel=None, **kwargs):\n",
    "    \"\"\"\n",
    "    Displays the most informative features in a model by showing a bar chart\n",
    "    of features ranked by their importances. Although primarily a feature\n",
    "    engineering mechanism, this visualizer requires a model that has either a\n",
    "    ``coef_`` or ``feature_importances_`` parameter after fit.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : Estimator\n",
    "        A Scikit-Learn estimator that learns feature importances. Must support\n",
    "        either ``coef_`` or ``feature_importances_`` parameters.\n",
    "\n",
    "    X : ndarray or DataFrame of shape n x m\n",
    "        A matrix of n instances with m features\n",
    "\n",
    "    y : ndarray or Series of length n, optional\n",
    "        An array or series of target or class values\n",
    "\n",
    "    ax : matplotlib Axes, default: None\n",
    "        The axis to plot the figure on. If None is passed in the current axes\n",
    "        will be used (or generated if required).\n",
    "\n",
    "    labels : list, default: None\n",
    "        A list of feature names to use. If a DataFrame is passed to fit and\n",
    "        features is None, feature names are selected as the column names.\n",
    "\n",
    "    relative : bool, default: True\n",
    "        If true, the features are described by their relative importance as a\n",
    "        percentage of the strongest feature component; otherwise the raw\n",
    "        numeric description of the feature importance is shown.\n",
    "\n",
    "    absolute : bool, default: False\n",
    "        Make all coeficients absolute to more easily compare negative\n",
    "        coeficients with positive ones.\n",
    "\n",
    "    xlabel : str, default: None\n",
    "        The label for the X-axis. If None is automatically determined by the\n",
    "        underlying model and options provided.\n",
    "\n",
    "    kwargs : dict\n",
    "        Keyword arguments that are passed to the base class and may influence\n",
    "        the visualization as defined in other Visualizers.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    ax : matplotlib axes\n",
    "        Returns the axes that the parallel coordinates were drawn on.\n",
    "    \"\"\"\n",
    "    # Instantiate the visualizer\n",
    "    visualizer = FeatureImportances(\n",
    "        model, ax, labels, relative, absolute, xlabel, **kwargs)\n",
    "\n",
    "    # Fit and transform the visualizer (calls draw)\n",
    "    visualizer.fit(X, y)\n",
    "    visualizer.finalize()\n",
    "\n",
    "    # Return the axes object on the visualizer\n",
    "    return visualizer.ax\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binary Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "occupancy = pd.read_csv('data/occupancy/occupancy.csv')\n",
    "features = [\n",
    "    \"temperature\", \"relative humidity\", \"light\", \"C02\", \"humidity\"\n",
    "]\n",
    "classes = [\"unoccupied\", \"occupied\"]\n",
    "X = occupancy[features]\n",
    "y = occupancy['occupancy']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr_importances = FeatureImportances(LogisticRegression())\n",
    "lr_importances.fit(X,y)\n",
    "lr_importances.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr_importances = FeatureImportances(LogisticRegression(), absolute=True)\n",
    "lr_importances.fit(X,y)\n",
    "lr_importances.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiclass Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "game = pd.read_csv('data/game/game.csv')\n",
    "classes = [\"win\", \"loss\", \"draw\"]\n",
    "\n",
    "game.replace({'loss':-1, 'draw':0, 'win':1, 'x':2, 'o':3, 'b':4}, inplace=True)\n",
    "X = game.iloc[:, game.columns != 'outcome']\n",
    "y = game['outcome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr_importances = FeatureImportances(LogisticRegression(), size=(1080, 720))\n",
    "lr_importances.fit(X,y)\n",
    "lr_importances.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr_importances = FeatureImportances(LogisticRegression(), absolute=True, size=(1080, 720))\n",
    "lr_importances.fit(X,y)\n",
    "lr_importances.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
